package com.renjun.smweb.commons.componet;

import com.renjun.smweb.commons.enums.EOperators;
import com.renjun.smweb.commons.enums.EStandTables;
import com.renjun.smweb.commons.global.DataDict;
import com.renjun.smweb.commons.util.BaseChecks;
import com.renjun.smweb.commons.util.Format;
import com.renjun.smweb.dao.bean.InsertParams;
import com.renjun.smweb.dao.bean.Parameter;
import com.renjun.smweb.dao.bean.QueryParams;
import com.renjun.smweb.dao.bean.UpdateParams;
import com.renjun.smweb.dao.pojo.LoginInfo;
import com.renjun.smweb.exceptions.DictIsNotFoundException;
import com.renjun.smweb.service.RegisterService.RegisterService;
import com.renjun.smweb.service.RuleValidationService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;

import javax.annotation.Resource;
import java.sql.SQLException;
import java.util.*;

/**
 * 所有的接口方法实现
 * Created by xlj on 2017/4/11.
 */
@Service
public class TempValidationService implements RuleValidationService {

    @Autowired
    private BaseDaoComponent baseDaoComponent;

    @Resource
    private RegisterService registerService;

    /**
     * 新增时候需要的校验
     * @param register
     * @return
     * @throws SQLException
     */
    private String checkZjhm(Map<String,Object> register) throws SQLException {
        LoginInfo loginInfo = (LoginInfo) register.get("userinfo");
        String yzjhm = (String) register.get("ysfzjh");//原证件号码
        String zjhm = (String) register.get("sfzjh");//新证件号码
        String zjlx = (String) register.get("sfzlx");//证件类型
        String studentId = (String) register.get("id");//学生id

        String time = Format.getDateTime();
        //原有的证件号码如果为空，就意味着是新增
        if(BaseChecks.hasEmptyStr(yzjhm)) {
            //不存在信息，就进行插入总表，插入字表
            //查询证件号码是否存在
            QueryParams queryAllStudent = QueryParams.createQueryParams("t_allstudentinfo");
            queryAllStudent.addQueryParams(Parameter.createParameter("zjhm",zjhm)
                    ,Parameter.createParameter("deleted","0"));
            Map<String, Object> allStudentMap = baseDaoComponent.selectOneDataByParams(queryAllStudent);
            if(null==allStudentMap) {
                String allId = UUID.randomUUID().toString();
                //插入总表
                Map<String,Object> allStudent = new HashMap<>();
                allStudent.put("zid",allId);//uuid
                allStudent.put("zjlx",zjlx);//证件类型
                allStudent.put("zjhm",zjhm);//证件号码
                allStudent.put("adduserid",loginInfo.getId());
                allStudent.put("addtime", time);
                allStudent.put("deleted", "0");//默认为0可用
                insertAllStudent(allStudent,loginInfo);//插入总表记录
                //插入子表
                Map<String,Object> allStudentRel = new HashMap<>();
                allStudentRel.put("id",UUID.randomUUID().toString());
                allStudentRel.put("zid",allId);
                allStudentRel.put("studentid",studentId);
                allStudentRel.put("adduserid",loginInfo.getId());
                allStudentRel.put("addtime", time);
                allStudentRel.put("deleted", "0");//默认为0可用
                insertAllStudentRel(allStudentRel,loginInfo);//插入字表记录
            } else {
                //存在，需要根据 学生id查询字表是否存在子表
                Map<String,Object> allStudentRel = new HashMap<>();
                allStudentRel.put("id",UUID.randomUUID().toString());
                allStudentRel.put("zid",allStudentMap.get("zid"));//获取总表的id
                allStudentRel.put("studentid",studentId);
                allStudentRel.put("adduserid",loginInfo.getId());
                allStudentRel.put("addtime", time);
                allStudentRel.put("deleted", "0");//默认为0可用
                insertAllStudentRel(allStudentRel,loginInfo);//插入字表记录
            }
        } else {
            //原证件号码不为空，意味着修改
            QueryParams queryYzjhm  = QueryParams.createQueryParams("V_M6_checkZjhm");
            queryYzjhm.addQueryParams(Parameter.createParameter("ZJHM",yzjhm),
                    Parameter.createParameter("studentid", EOperators.不包含,studentId));
            List<Map<String, Object>> allStudentList = baseDaoComponent.selectDataByParams(queryYzjhm);
            if(0==allStudentList.size()) {
                //原证件号码不存在
                //1.修改总表原记录为删除状态
                UpdateParams updateAll = UpdateParams.createUpdateParams("T_ALLSTUINFO");
                Map<String,Object> updateAllMap = new HashMap<>();
                updateAllMap.put("DELETED","1");
                updateAllMap.put("DELETEDTIME",time);
                updateAllMap.put("DELETEDUSERID",loginInfo.getId());
                updateAll.addParamsForMap(updateAllMap);
                updateAll.addWhereParameter(Parameter.createParameter("zjhm",yzjhm));
                baseDaoComponent.updateDataByParams(updateAll);
            }
            QueryParams queryAllStudent = QueryParams.createQueryParams("t_allstudentinfo");
            queryAllStudent.addQueryParams(Parameter.createParameter("zjhm",zjhm)
                    ,Parameter.createParameter("deleted","0"));
            Map<String, Object> allStudentMap = baseDaoComponent.selectOneDataByParams(queryAllStudent);
            Map<String,Object> updateAllRel = new HashMap<>();
            if(null==allStudentMap) {
                //插入总表
                Map<String,Object> allStudent = new HashMap<>();
                String allId = UUID.randomUUID().toString();
                allStudent.put("zid",allId);//uuid
                allStudent.put("zjlx",zjlx);//证件类型
                allStudent.put("zjhm",zjhm);//证件号码
                allStudent.put("adduserid",loginInfo.getId());
                allStudent.put("addtime", time);
                allStudent.put("deleted", "0");//默认为0可用
                insertAllStudent(allStudent,loginInfo);//插入总表记录
                //zid是取的新增的还是取的数据库原有的
                updateAllRel.put("zid",allId);
            } else {
                updateAllRel.put("zid",allStudentMap.get("zid"));
            }
            updateAllRel.put("UPDATEUSERID",loginInfo.getId());
            updateAllRel.put("UPDATETIME",time);
            //原证件号码存在
            //1.修改子表
            UpdateParams updateRel = UpdateParams.createUpdateParams("T_ALLSTUINFO_REL");
            try {
                updateRel.setDbLog(loginInfo);
            } catch (Exception e) {
                e.printStackTrace();
            }
            updateRel.addWhereParameters(Parameter.createParameter("studentid",studentId));
            baseDaoComponent.updateDataByParams(updateRel);
        }
        return "";
    }

    /**
     * 删除 基本信息，需要校验总表，字表是否标记为删除状态
     * @param register
     * @throws SQLException
     */
    public void checkDeletedZjhm(Map<String,Object> register) throws SQLException {
        LoginInfo loginInfo = (LoginInfo) register.get("userinfo");
        String zjhm = (String) register.get("sfzjh");//证件号码
        String studentId = (String) register.get("id");//学生id
        QueryParams queryYzjhm  = QueryParams.createQueryParams("V_M6_checkZjhm");
        queryYzjhm.addQueryParams(Parameter.createParameter("ZJHM",zjhm),
                Parameter.createParameter("studentid", EOperators.不包含,studentId));
        try {
            queryYzjhm.setDbLog(loginInfo);
        } catch (Exception e) {
            e.printStackTrace();
        }
        List<Map<String, Object>> allStudentList = baseDaoComponent.selectDataByParams(queryYzjhm);
        if(0==allStudentList.size()) {
            //原证件号码不存在
            //1.修改总表原记录为删除状态
            UpdateParams updateAll = UpdateParams.createUpdateParams("T_ALLSTUINFO");
            Map<String,Object> updateAllMap = new HashMap<>();
            updateAllMap.put("DELETED","1");
            updateAllMap.put("DELETEDTIME",Format.getDateTime());
            updateAllMap.put("DELETEDUSERID",loginInfo.getId());
            updateAll.addParamsForMap(updateAllMap);
            updateAll.addWhereParameter(Parameter.createParameter("zjhm",zjhm));
            try {
                updateAll.setDbLog(loginInfo);
            } catch (Exception e) {
                e.printStackTrace();
            }
            baseDaoComponent.updateDataByParams(updateAll);
        }
        Map<String,Object> updateAllRelMap = new HashMap<>();
        updateAllRelMap.put("DELETED","1");
        updateAllRelMap.put("DELETEDTIME",Format.getDateTime());
        updateAllRelMap.put("DELETEDUSERID",loginInfo.getId());
        UpdateParams updateRel = UpdateParams.createUpdateParams("T_ALLSTUINFO_REL");
        updateRel.addParamsForMap(updateAllRelMap);
        updateRel.addWhereParameters(Parameter.createParameter("studentid",studentId));
        try {
            updateRel.setDbLog(loginInfo);
        } catch (Exception e) {
            e.printStackTrace();
        }
        baseDaoComponent.updateDataByParams(updateRel);
    }

    /**
     * 新增字表
     * @param allStudentRel
     * @param loginInfo
     * @throws SQLException
     */
    private void insertAllStudentRel(Map<String,Object> allStudentRel,LoginInfo loginInfo) throws SQLException {
        InsertParams insertAllStudentRel = InsertParams.createInsertParams("T_ALLSTUINFO_REL");
        insertAllStudentRel.addParamsForMap(allStudentRel);
        try {
            insertAllStudentRel.setDbLog(loginInfo);
        } catch (Exception e) {
            e.printStackTrace();
        }
        baseDaoComponent.insertDataByParams(insertAllStudentRel);
    }

    /**
     * 新增总表记录
     * @param allStudentMap
     * @param loginInfo
     * @throws SQLException
     */
    private void insertAllStudent(Map<String,Object> allStudentMap,LoginInfo loginInfo) throws SQLException {
        InsertParams insertAllStudent = InsertParams.createInsertParams("T_ALLSTUINFO");
        insertAllStudent.addParamsForMap(allStudentMap);
        try {
            insertAllStudent.setDbLog(loginInfo);
        } catch (Exception e) {
            e.printStackTrace();
        }
        baseDaoComponent.insertDataByParams(insertAllStudent);
    }

    @Override
    public String checkImportRegisterJs(Map<String, Object> registerStudent) throws SQLException {
        StringBuffer sb = new StringBuffer();
        String xm = (String) registerStudent.get("xm");
        LoginInfo loginInfo = (LoginInfo) registerStudent.get("userinfo");
        sb.append(xm);
        String djxx = (String) registerStudent.get("djxx");
        sb.append(checkDjxx(djxx, loginInfo));//校验登记学校
        String nj = (String) registerStudent.get("njdm");
        sb.append(checkNj(nj));//校验年级
        String sfzjlx = (String) registerStudent.get("sfzlx");
        sb.append(checkZjlx(sfzjlx));//校验证件类型
        sb.append(checkXm(xm,sfzjlx));//校验姓名
        String xb = (String) registerStudent.get("xb");
        sb.append(checkXb(xb));//校验性别
        String csrq = (String) registerStudent.get("csrq");
        sb.append(checkCsrq(csrq));//校验出生日期
        sb.append(checkSfzjh(registerStudent,loginInfo));//校验证件号码
        String gatxz = (String) registerStudent.get("gatxz");
        String sfzjh = (String) registerStudent.get("sfzjh");
        sb.append(checkGatqw(sfzjlx,gatxz,sfzjh));//校验港澳台侨外
        String gj = (String) registerStudent.get("gjdq");
        sb.append(checkGj(gj,sfzjlx));//校验国籍
        String jkzk = (String) registerStudent.get("jkzk");
        sb.append(checkJkzk(jkzk));//校验健康状况
        String mz = (String) registerStudent.get("mz");
        sb.append(checkMz(mz,sfzjlx));//校验民族
        String sffhjs = (String) registerStudent.get("sffhjs");
        sb.append(checkSffhjs(sffhjs));//校验是否符合计划生育
        String jhrxm = (String) registerStudent.get("jhrxm");
        String jhrzjlx = ((String) registerStudent.get("jhrzjlx"));
        sb.append(checkJhrxm(jhrxm,jhrzjlx));//校验监护人姓名
        sb.append(checkJhrzjlx(jhrzjlx));//校验监护人证件类型
        String jhrxb = (String) registerStudent.get("jhrxb");
        sb.append(checkJhrXb(jhrxb));//校验监护人性别
        String jhrgx = (String) registerStudent.get("jhrgx");
        sb.append(checkJhrgx(jhrgx));//校验监护人关系
        String jhrzjhm = ((String) registerStudent.get("jhrzjhm"));
        sb.append(checkJhrzjhm(jhrzjhm,jhrzjlx,jhrxb));//校验监护人证件号码
        //【联系电话】：1、必填。2、只允许数字和英文中划线、英文空格。
        String jhrdh = (String) registerStudent.get("jhrdh");
        sb.append(checkJhrdh(jhrdh));//校验监护人电话
        return sb.toString();
    }

    @Override
    public String checkAddRegisterStudentJs(Map<String, Object> registerStudent) throws SQLException {
        StringBuffer sb = new StringBuffer();
        String xm = (String) registerStudent.get("xm");
        LoginInfo loginInfo = (LoginInfo) registerStudent.get("userinfo");
        sb.append(xm);
        String djxx = (String) registerStudent.get("djxx");
        sb.append(checkDjxx(djxx, loginInfo));//校验登记学校
        String nj = (String) registerStudent.get("njdm");
        sb.append(checkNj(nj));//校验年级
        String sfzjlx = (String) registerStudent.get("sfzlx");

        sb.append(checkZjlx(sfzjlx));//校验证件类型

        sb.append(checkXm(xm,sfzjlx));//校验姓名

        String xb = (String) registerStudent.get("xb");
        sb.append(checkXb(xb));//校验性别

        String csrq = (String) registerStudent.get("csrq");
        sb.append(checkCsrq(containsDate(csrq)));//校验出生日期

        sb.append(checkSfzjh(registerStudent,loginInfo));//校验证件号码

        String gatxz = (String) registerStudent.get("gatxz");
        String sfzjh = (String) registerStudent.get("sfzjh");
        sb.append(checkGatqw(sfzjlx,gatxz,sfzjh));//校验港澳台侨外

        String gj = (String) registerStudent.get("gjdq");
        sb.append(checkGj(gj,sfzjlx));//校验国籍

        String jkzk = (String) registerStudent.get("jkzk");
        sb.append(checkJkzk(jkzk));//校验健康状况

        String mz = (String) registerStudent.get("mz");
        sb.append(checkMz(mz,sfzjlx));//校验民族

        String sffhjs = (String) registerStudent.get("sffhjs");
        sb.append(checkSffhjs(sffhjs));//校验是否符合计划生育

        String jhrxm = (String) registerStudent.get("jhrxm");
        String jhrzjlx = ((String) registerStudent.get("jhrzjlx"));
        sb.append(checkJhrxm(jhrxm,jhrzjlx));//校验监护人姓名

        sb.append(checkJhrzjlx(jhrzjlx));//校验监护人证件类型

        String jhrxb = (String) registerStudent.get("jhrxb");
        sb.append(checkJhrXb(jhrxb));//校验监护人性别

        String jhrgx = (String) registerStudent.get("jhrgx");
        sb.append(checkJhrgx(jhrgx));//校验监护人关系

        String jhrzjhm = ((String) registerStudent.get("jhrzjhm"));
        sb.append(checkJhrzjhm(jhrzjhm,jhrzjlx,jhrxb));//校验监护人证件号码

        //【联系电话】：1、必填。2、只允许数字和英文中划线、英文空格。
        String jhrdh = (String) registerStudent.get("jhrdh");
        sb.append(checkJhrdh(jhrdh));//校验监护人电话

        //添加的时候需要校验
        String jzzlx = (String) registerStudent.get("jzzlx");
        String hksf = (String) registerStudent.get("hksf");
        sb.append(checkJzzlx(jzzlx,sfzjlx,hksf));//居住证类型

        String jzzhm = (String) registerStudent.get("jzzhm");
        sb.append(checkJzzhm(jzzhm,jzzlx));//居住证号码，

        String jzzyxq = (String) registerStudent.get("jzzyxq");
        sb.append(checkJzzyxq(jzzyxq,jzzlx));//校验居住证有效期

        String hkxz = (String) registerStudent.get("hkxz");
        sb.append(checkHkxz(hkxz,sfzjlx));//户口性质校验

        String fnhklx = (String) registerStudent.get("fnhklx");
        sb.append(checkFnhklx(fnhklx,hkxz));//非农业户口性质校验

        String hjlb = (String) registerStudent.get("hjlb");
        sb.append(checkHjlb(hjlb,sfzjlx));//校验户籍类别

        String sfrhyz = (String) registerStudent.get("sfrhyz");
        sb.append(checkSfrhyz(sfrhyz));//是否人户一致

        String hjdjr = (String)registerStudent.get("hjdjr");
        sb.append(checkHjdjr(hjdjr,sfzjlx));//户籍登记日期

        String hzgx = (String) registerStudent.get("hzgx");
        sb.append(checkHzgx(hzgx,sfzjlx));//户主关系

        sb.append(checkHksf(sfzjlx,hksf));//户口省份校验

        sb.append(checkShHksf(registerStudent));//上海市校验户口详细信息
        String wsshkdz = (String) registerStudent.get("wsshkdz");
        sb.append(checkWsHksf(hksf,wsshkdz));

        String hkqx = (String) registerStudent.get("hkqx");
        sb.append(checkHkqx(hkqx,sfzjlx));//户口区县

        String xzzsf = (String) registerStudent.get("xzzsf");//现在居住地省份
        sb.append(checkXzzsf(xzzsf));

        String xzzqx = (String) registerStudent.get("xzzqx");
        sb.append(checkXzzqx(xzzqx));//现居住地区县

        String xzzjd = (String) registerStudent.get("xzzjd");
        sb.append(checkXzzjd(xzzjd));//现居住街道

        String xzzjw = (String) registerStudent.get("xzzjw");
        sb.append(checkXzzjw(xzzjw));//现居住居委

        String xzzrod = (String) registerStudent.get("xzzrod");
        sb.append(checkXzzrod(xzzrod));//现居住地址路

        String xzzz = (String) registerStudent.get("xzzz");
        sb.append(checkXzzz(xzzz));// 居住组

        String xzzldh = (String) registerStudent.get("xzzldh");
        sb.append(checkXzzldh(xzzldh));// 现住址楼栋号

        String xzzs = (String) registerStudent.get("xzzs");
        sb.append(checkXzzs(xzzs));// 现住址室

        String xzzyzbm = (String) registerStudent.get("xzzyzbm");
        sb.append(checkXzzyzbm(xzzyzbm));//现居住邮编

        //联系电话 只允许最多11个字符（0 1 2 3 4 5 6 7 8 9 - 的组合），首位只允许数字。
        String lxdh = (String) registerStudent.get("lxdh");
        sb.append(checkLxdh(lxdh));

        sb.append(checkZfxz(registerStudent));//住房性质

        String gfrgx = (String) registerStudent.get("gfrgx");
        sb.append(checkGfrgx(gfrgx));//购房人关系

        String sfnmgtzzn = (String) registerStudent.get("sfnmgtzzn");
        sb.append(checkSfnmgtzzn(sfzjlx,sfnmgtzzn,hjlb));//是否农民工同住子女

        sb.append(checkSflqcjz(registerStudent));//是否领取残疾证

        String ryyj = (String) registerStudent.get("ryyj");
        sb.append(checkRyyj(ryyj)); // 入园依据

        String ryyjlb = (String) registerStudent.get("ryyjlb");
        sb.append(checkRyyjlb(ryyjlb));//入园依据类别

        sb.append(checkJsRyyjlb(registerStudent));//金山特有的入园依据，没有读取缓存数据

        String syqk = (String) registerStudent.get("syqk");
        sb.append(checkSyqk(syqk));//生源情况

        String jhrxl = (String) registerStudent.get("jhrxl");
        sb.append(checkJhrxl(jhrxl)); //监护人信息校验：1.监护人学历

        String jhrgzdw = (String) registerStudent.get("jhrgzdw");
        sb.append(checkJhrgzdw(jhrgzdw)); //监护人工作单位

        sb.append(checkJhrhksf(registerStudent));//监护人省份，区县

        sb.append(checkJhrjzzlx(registerStudent));//监护人居住证类型

        return sb.toString();
    }

    @Override
    public String checkAddRegisterStudentHk(Map<String, Object> registerStudent) throws SQLException {
        StringBuffer sb = new StringBuffer();
        String xm = (String) registerStudent.get("xm");
        LoginInfo loginInfo = (LoginInfo) registerStudent.get("userinfo");
        sb.append(xm);
        String djxx = (String) registerStudent.get("djxx");
        sb.append(checkDjxx(djxx, loginInfo));//校验登记学校-虹口新增
        String nj = (String) registerStudent.get("njdm");
        sb.append(checkNj(nj));//校验年级-虹口新增
        String sfzjlx = (String) registerStudent.get("sfzlx");

        sb.append(checkXm(xm,sfzjlx));//姓名校验-虹口新增

        sb.append(checkZjlx(sfzjlx));//证件类型校验-虹口新增

        String xb = (String) registerStudent.get("xb");
        sb.append(checkXb(xb));//性别校验--虹口新增

        sb.append(checkSfzjh(registerStudent,loginInfo));//证件号码校验--虹口新增

        String csrq = (String) registerStudent.get("csrq");
        sb.append(checkCsrq(containsDate(csrq)));//出生日期校验--虹口新增

        String mz = (String) registerStudent.get("mz");
        sb.append(checkMz(mz,sfzjlx));//民族校验--虹口新增

        String sfdszv = (String) registerStudent.get("sfdszv");
        sb.append(checkSfdszv(sfdszv));//是否独生子女--虹口新增

        String jkzk = (String) registerStudent.get("jkzk");
        sb.append(checkJkzk(jkzk));//健康状况--虹口新增

        String hksf = (String) registerStudent.get("hksf");
        sb.append(checkHksf(sfzjlx,hksf));//户口省份--虹口新增

        sb.append(checkShHksf(registerStudent));//上海市校验户口详细信息--虹口新增
        String wsshkdz = (String) registerStudent.get("wsshkdz");
        sb.append(checkWsHksf(hksf,wsshkdz));

        String hkqx = (String) registerStudent.get("hkqx");
        sb.append(checkHkqx(hkqx,sfzjlx));//户口区县--虹口新增

        String xzzsf = (String) registerStudent.get("xzzsf");//现在居住地省份--虹口新增
        sb.append(checkXzzsf(xzzsf));

        String xzzqx = (String) registerStudent.get("xzzqx");
        sb.append(checkXzzqx(xzzqx));//现居住地区县--虹口新增

        String xzzjd = (String) registerStudent.get("xzzjd");
        sb.append(checkXzzjd(xzzjd));//现居住街道--虹口新增

        String xzzjw = (String) registerStudent.get("xzzjw");
        sb.append(checkXzzjw(xzzjw));//现居住居委--虹口新增

        String xzzrod = (String) registerStudent.get("xzzrod");
        sb.append(checkXzzrod(xzzrod));//现居住地址路--虹口新增

        String xzzz = (String) registerStudent.get("xzzz");
        sb.append(checkXzzz(xzzz));// 居住组--虹口新增

        String xzzldh = (String) registerStudent.get("xzzldh");
        sb.append(checkXzzldh(xzzldh));// 现住址楼栋号--虹口新增

        String xzzs = (String) registerStudent.get("xzzs");
        sb.append(checkXzzs(xzzs));// 现住址室--虹口新增

        String xzzyzbm = (String) registerStudent.get("xzzyzbm");
        sb.append(checkXzzyzbm(xzzyzbm));//现居住邮编--虹口新增

        return null;
    }

    /**
     * 日期去除横杠
     * @param date
     * @return
     */
    private String containsDate(String date) {
        if(!BaseChecks.hasEmptyStr(date)) {//日期需要特别处理
            if(date.contains("-")) {
                date = date.replace("-","");
               return date;
            }
        }
        return date;
    }

    /**
     * 是否独生子女-目前虹口特有字段校验
     * @param sfdszv
     * @return
     */
    private String checkSfdszv(String sfdszv) {
        if(BaseChecks.hasEmptyStr(sfdszv)) {
            return "__请填写是否独生子女" ;
        }
        if(!BaseChecks.hasEmptyStr(sfdszv)) {
            try {
                DataDict.getChineseValueByCode(EStandTables.是否独身子女表,sfdszv);
            } catch (DictIsNotFoundException e) {
                return "__是否独生子女不符合标准表";
            }
        }
        return "";
    }
    /**
     * 校验登记学校
     * @param djxx
     * @param loginInfo
     * @return
     * @throws SQLException
     */
    public String checkDjxx(String djxx ,LoginInfo loginInfo) throws SQLException {
        if(BaseChecks.hasEmptyStr(djxx)) {
            return "__请填写学校代码";
        }
        if(!BaseChecks.hasEmptyStr(djxx)) {
            if(!djxx.matches("[0-9]{10}")) {
                return "__请填写10位数字的学校代码";
            }
            //校验是否学校代码存在？
            if(!checkSchool(djxx,loginInfo)) {
                return  "__学校代码不存在，请重新填写学校代码";
            }
            //区管校验区是否一致
            String roleType = loginInfo.getRoletype();
            if("2".equals(roleType)) {
                String qxdm = loginInfo.getDistrictcode();
                String xxqxdm = djxx.substring(0,6);
                if(!qxdm.equals(xxqxdm)) {
                    return "__区县不匹配不能进行登记";
                }
            }
            if("3".equals(roleType)) {
                String schoolcode = loginInfo.getSchoolcode();
                if(!schoolcode.equals(djxx)) {
                    return "__学校不匹配不能进行登记";
                }
            }
        }
        return "";
    }

    /**
     * 校验年级
     * @param nj
     * @return
     */
    public  String checkNj(String nj) {
        if(BaseChecks.hasEmptyStr(nj)) {
            return "__请填写登记年级" ;
        }
        if(!BaseChecks.hasEmptyStr(nj)) {
            try {
                DataDict.getChineseValueByCode(EStandTables.年级表,nj);
            } catch (DictIsNotFoundException e) {
                return "__年级不符合标准表";
            }

            if(!("01".equals(nj) || "02".equals(nj))) {
                return "__年级只允许选择输入“托班”、“小班”。";
            }
        }
        return "";
    }

    /**
     * 校验证件类型
     * @param sfzjlx 证件类型
     * @return
     */
    public String checkZjlx(String sfzjlx) {
        //【证件类型】：1、必填。2、多选一：居民身份证、香港特区身份证明、澳门特区身份证明、台湾居民来往大陆通行证、境外永久居住证、护照、其他。
        if(BaseChecks.hasEmptyStr(sfzjlx)) {
            return "__请填写证件类型";
        }
        if(!BaseChecks.hasEmptyStr(sfzjlx)) {
            //证件类型表
            try {
                DataDict.getChineseValueByCode(EStandTables.证件类型表,sfzjlx);
            } catch (DictIsNotFoundException e) {
                return "__证件类型不符合标准表";
            }
        }
        return "";
    }


    /**
     * 校验姓名
     * @param xm 姓名
     * @param sfzjlx 证件类型
     * @return
     */
    public String checkXm(String xm,String sfzjlx) {
        /**
         【姓名】：1、必填。2、【证件类型】为“护照”和“境外永久居住证”时，不允许汉字；3、允许输入汉字时，不允许存在空格。
         */
        if(BaseChecks.hasEmptyStr(xm)) {
            return "__姓名不能为空";
        }
        if(!BaseChecks.hasEmptyStr(xm)) {
            //姓名校验
            if("1".equals(sfzjlx)||"D".equals(sfzjlx)||"8".equals(sfzjlx)||"Z".equals(sfzjlx)) {
                if(" ".contains(xm)) {
                    return "__姓名不能有空格";
                }
                if (!xm.matches("[\\u4e00-\\u9fa5.·]*")) {
                    return "__姓名必须为中文、“·”";
                }
            }
            if("A".equals(sfzjlx)||"9".equals(sfzjlx)) {
                if(" ".equals(xm.substring(0,1))){
                    return "__姓名首位不能为空格、";
                }
                if (!xm.matches("^[A-Za-z\\s,.、-]*$")) {
                    return "__姓名必须为英文、英文空格、“-”、“.”、“,”";
                }
            }
        }
        return "";
    }

    /**
     * 校验性别
     * @param xb 性别
     * @return
     */
    public String checkXb(String xb) {
        //【性别】：1、必填。2、只允许选择输入“男”、“女”。
        if(BaseChecks.hasEmptyStr(xb)) {
            return "__性别不能为空";
        }
        if(!BaseChecks.hasEmptyStr(xb)) {
            //性别
            try {
                DataDict.getChineseValueByCode(EStandTables.性别表,xb);
            } catch (DictIsNotFoundException e) {
                return "__性别不符合标准表";
            }
        }
        return "";
    }

    /**
     * 校验出生日期
     * @param csrq 出生日期
     * @return
     */
    public String checkCsrq(String csrq) {
        //1、8位数字，如20120101        2、居民身份证类型时：与证件号码中的出生日期匹配。        3、证件类型“其他”：与证件号码中的出生日期匹配。
        if(BaseChecks.hasEmptyStr(csrq)) {
            return "__请填写出生日期";
        }
        if(!BaseChecks.hasEmptyStr(csrq)) {
            if(!csrq.matches("\\d{8}")) {
                return "__请填写正确的出生日期格式";
            }
        }
        return "";
    }

    /**
     * 校验身份证号码，附带名族，
     * @param registerStudent
     * @param loginInfo
     * @return
     * @throws SQLException
     */
    public String checkSfzjh(Map<String,Object> registerStudent,LoginInfo loginInfo) throws SQLException {
        //证件号码
        String sfzjlx = (String) registerStudent.get("sfzlx");
        String sfzjh = (String) registerStudent.get("sfzjh");
        String csrq = (String) registerStudent.get("csrq");
        String xb = (String) registerStudent.get("xb");
        //1.不能为空
        if(!"Z".equals(sfzjlx)) {
            if(BaseChecks.hasEmptyStr(sfzjh)) {
                return "__证件号码不能为空";
            }
        }
        String districtCode = loginInfo.getDistrictcode();//后三位
        districtCode = districtCode.substring(districtCode.length()-3,districtCode.length());

        /**
         【证件号码】：
         1、不允许有中文字符
         2、居民身份证类型时：只允许大写字母'X'和数字(0,1,2,3,4,5,6,7,8,9)，且X只能在最后一位。
         3、居民身份证类型时：与学生的【性别】比较是否一致
         4、居民身份证类型时：长度满足18位
         5、不允许重复
         6、【证件类型】为“其他”时，不需填写（系统根据《上海市中小学学生学籍号编制规则》自动生成临号）
         7、必填
         8、存在英文字母时，需大写。
         */
        //证件类型为其他的时候
        if("Z".equals(sfzjlx)) {
            //当证件号码不为空的时候校验，
            if(!BaseChecks.hasEmptyStr(sfzjh)){
                //生成临时身份证 4位数流水
                //校验是否符合规范
                String ls = sfzjh.substring(0,2);
                if(!"LS".equals(ls)) {
                    return "__临时证件号码必须为LS开头";
                }
                String qx = sfzjh.substring(2,5);
                if(!districtCode.equals(qx)) {
                    return "__临时证件号码区县不匹配";
                }
                String scsrq = sfzjh.substring(5,13);
                if(!csrq.equals(scsrq)) {
                    return "__临时证件号码出生日期不匹配";
                }
                String cxb = sfzjh.substring(13,14);
                if(!xb.equals(cxb)) {
                    return "__临时证件号码性别不匹配";
                }
            }
            if(BaseChecks.hasEmptyStr(sfzjh)){
                //生成临时身份证 4位数流水
                sfzjh = "LS"+districtCode+csrq+xb+(new Random()).nextInt(9999);
                //校验重复 重复重新生成个
                Map<String,Object> registerMap = new HashMap<>();
                registerMap.put("sfzjh",sfzjh);
                registerMap.put("userinfo",loginInfo);
                registerMap.put("id",registerMap.get("id"));
                if(registerService.checkRegisterStudentSfzjh(registerMap)){
                    sfzjh = "LS"+districtCode+csrq+xb+(new Random()).nextInt(9999);
                }
            }

        }

        //当证件号码不为空的时候
        if(!BaseChecks.hasEmptyStr(sfzjh)){
            //当为居民身份证需要校验
            /**
             2、居民身份证类型时：只允许大写字母'X'和数字(0,1,2,3,4,5,6,7,8,9)，且X只能在最后一位。
             3、居民身份证类型时：与学生的【性别】比较是否一致
             4、居民身份证类型时：长度满足18位
             5、不允许重复
             */
            if("1".equals(sfzjlx)) {
                if(18!=sfzjh.length()) {
                    return "__证件类型为居民身份证，需要填写18位";
                }
                if(!isCardId(sfzjh)) {
                    return "__身份证填写错误";
                }
                if(BaseChecks.isChineseChar(sfzjh)) {
                    return "__身份证不允许有中文字符";
                }
                String sfzxb = sfzjh.substring(sfzjh.length()-2,sfzjh.length()-1);
                Integer intXb = Integer.parseInt(sfzxb);
                //除不尽就是男   性别字段 xb：1是男，2是女
                if (0==(intXb%2)) {
                    if ("1".equals(xb)) {
                        return "__身份证和性别不匹配";
                    }
                } else {
                    if ("2".equals(xb)) {
                        return "__身份证和性别不匹配";
                    }
                }
                //出生日期
                String scsrq = sfzjh.substring(6,14);
                if(!scsrq.equals(csrq)) {
                    return "__身份证和出生日期不匹配";
                }
            }
            //校验重复
            Map<String,Object> registerMap = new HashMap<>();
            registerMap.put("sfzjh",sfzjh);
            registerMap.put("userinfo",loginInfo);
            registerMap.put("id",registerStudent.get("id"));
            //删除
            if(registerService.checkRegisterStudentSfzjh(registerMap)){
                return "__证件号码重复";
            }
        }
        return "";
    }

    /**
     * 校验民族
     * @param mz
     * @param sfzjlx
     * @return
     */
    public String checkMz(String mz, String sfzjlx) {
        if("1".equals(sfzjlx)) {
            //【民族】：1、【证件类型】为“居民身份证”时填写。   2、按《民族代码表》填写。如汉族、回族等。
            if(BaseChecks.hasEmptyStr(mz)){
                return "__当证件类型为居民身份证，需要填写民族";
            }
            if(!BaseChecks.hasEmptyStr(mz)){
                try {
                    DataDict.getChineseValueByCode(EStandTables.民族表,mz );
                } catch (DictIsNotFoundException e) {
                    return "__民族不符合标准表";
                }
            }
        }
        return  "";
    }

    /**
     * 是否符合计划生育
     * @param sffhjs
     * @return
     */
    public String checkSffhjs(String sffhjs){
        //【是否符合计划生育政策】1、【证件类型】为“居民身份证”时填写。2、只填写是、否。
        if(BaseChecks.hasEmptyStr(sffhjs)){
            return "__当证件类型为居民身份证，请选择是否符合计划生育政策";
        }
        if(!BaseChecks.hasEmptyStr(sffhjs)){
            try {
                DataDict.getChineseValueByCode(EStandTables.是否标志表,sffhjs);
            } catch (DictIsNotFoundException e) {
                return "__是否符合计划生育政策不符合标准表";
            }
        }
        return "";
    }

    /**
     * 校验港澳台侨外
     * @param sfzjlx 证件类型
     * @param gatxz 港澳台证件号码
     * @param sfzjh 证件号码(新增的时候需要校验)
     * @return
     */
    public String checkGatqw(String sfzjlx,String gatxz,String sfzjh) {
        //香港和澳门证件类型的时候需要校验，港澳台证件号码
        if("D".equals(sfzjlx)) {
            //如果港澳通行证为空，去获取证件号码
            if(BaseChecks.hasEmptyStr(gatxz)) {
                gatxz= sfzjh;
            }
            if(!BaseChecks.hasEmptyStr(gatxz)) {
                if(BaseChecks.isChineseChar(gatxz)) {
                    return "__港澳通行证号不允许有中文字符";
                }
                if(!gatxz.matches("^[A-Z0-9]+$")) {
                    return "__港澳通行证号,只允许输入英文字符和数字，其中英文字母需大写。";
                }
                if(" ".equals(gatxz.substring(0,1))){
                    return "__澳通行证号,首位不能为空格、";
                }
            }
        }
        return "";
    }

    /**
     * 校验国籍
     * @param gj
     * @param sfzjlx
     * @return
     */
    public String checkGj(String gj ,String sfzjlx) {
        //国籍必填
        if(BaseChecks.hasEmptyStr(gj)) {
            return "__请填写国籍";
        }
        if(!BaseChecks.hasEmptyStr(gj)) {
            try {
                DataDict.getChineseValueByCode(EStandTables.国籍地区表, gj);
            } catch (DictIsNotFoundException e) {
                return "__国籍不符合标准表";
            }
            /**
             156	中国
             344	中国香港
             446	中国澳门
             158	中国台湾
             1	居民身份证
             6	香港特区身份证明
             7	澳门特区身份证明
             8	台湾居民来往大陆通行证
             C	其他
             3、【证件类型】为“香港特区身份证明”的，国籍必须选择为“中国香港”。
             4、【证件类型】为“澳门特区身份证明”的，国籍必须选择为“中国澳门”。
             5、【证件类型】为“台湾居民来往大陆通行证”的，国籍必须选择为“中国台湾”。
             6、【证件类型】为“居民身份证”或“其他”的，国籍必须选择为“中国”。
             7、【证件类型】为“护照”或“境外永久居住证”的，国籍不能选择为“中国”、“中国香港”、“中国澳门”、“中国台湾”。
             */
            if ("D".equals(sfzjlx)) {
                if("344".equals(gj) || "446".equals(gj))  {
                } else {
                    return "__【证件类型】为“港澳居民来往内地通行证”的，国籍必须选择为“中国澳门或者中国香港”。";
                }
            }
            if("8".equals(sfzjlx)&&!"158".equals(gj)) {
                return "__【证件类型】为“台湾居民来往大陆通行证”的，国籍必须选择为“中国台湾”";
            }
            if(("1".equals(sfzjlx)||"Z".equals(sfzjlx))&&!"156".equals(gj)) {
                return "__【证件类型】为“居民身份证”或“其他”的，国籍必须选择为“中国”。";
            }
            if(("9".equals(sfzjlx)||"A".equals(sfzjlx)) &&
                    ("344".equals(gj)||"446".equals(gj)||"158".equals(gj)||"156".equals(gj)) ) {
                return "__【证件类型】为“护照”或“境外永久居住证”的，国籍不能选择为“中国”、“中国香港”、“中国澳门”、“中国台湾”。";
            }
        }
        return "";
    }

    /**
     * 健康状况
     * @param jkzk
     * @return
     */
    public String checkJkzk(String jkzk) {
        //【健康状况】1、必填。     2、多选一：健康或良好,一般或较弱,有慢性病,残疾。
        if(BaseChecks.hasEmptyStr(jkzk)) {
            return "__请填写健康状况";
        }
        if(!BaseChecks.hasEmptyStr(jkzk)) {
            try {
                DataDict.getChineseValueByCode(EStandTables.健康状况表, jkzk);
            } catch (DictIsNotFoundException e) {
                return "__健康状况不符合标准表";
            }
        }
        return "";
    }

    /**
     * 校验监护人姓名
     * @param jhrxm
     * @return
     */
    public String checkJhrxm(String jhrxm,String jhrzjlx) {
        //【监护人姓名】：必填
        if(BaseChecks.hasEmptyStr(jhrxm)) {
            return "__监护人姓名不能为空";
        }
        if(!BaseChecks.hasEmptyStr(jhrxm)) {
            //姓名校验
            if("1".equals(jhrzjlx)||"6".equals(jhrzjlx)||"7".equals(jhrzjlx)||"8".equals(jhrzjlx)||"Z".equals(jhrzjlx)) {
                if(" ".contains(jhrxm)) {
                    return "__监护人姓名不能有空格";
                }
                if (!jhrxm.matches("[\\u4e00-\\u9fa5.·]*")) {
                    return "__监护人姓名必须为中文、“·”";
                }
            }
            if("A".equals(jhrzjlx)||"9".equals(jhrzjlx)) {
                if(" ".equals(jhrxm.substring(0,1))){
                    return "__监护人姓名首位不能为空格、";
                }
                if (!jhrxm.matches("^[A-Za-z\\s,.、-]*$")) {
                    return "__监护人姓名必须为英文、英文空格、“-”、“.”、“,”";
                }
            }
        }
        return "";
    }

    /**
     * 校验监护人证件类型
     * @param jhrzjlx
     * @return
     */
    public String checkJhrzjlx(String jhrzjlx) {
        //jhrzjlx 监护人证件类型 【监护人证件类型】        1、必填。 2、多选一：居民身份证、香港特区身份证明、澳门特区身份证明、台湾居民来往大陆通行证、境外永久居住证、护照、其他。
        if(BaseChecks.hasEmptyStr(jhrzjlx)) {
            return "__监护人证件类型不能为空";
        }
        if(!BaseChecks.hasEmptyStr(jhrzjlx)) {
            try {
                DataDict.getChineseValueByCode(EStandTables.证件类型表, jhrzjlx);
            } catch (DictIsNotFoundException e) {
                return "__监护人证件类型不符合标准值";
            }
        }
        return "";
    }

    /**
     * 监护人性别
     * @param jhrxb
     * @return
     */
    public String checkJhrXb(String jhrxb) {
        //【监护人性别】：1、必填。2、只允许选择输入“男”、“女”。
        if(BaseChecks.hasEmptyStr(jhrxb)) {
            return "__监护人性别不能为空";
        }
        if(!BaseChecks.hasEmptyStr(jhrxb)) {
            try {
                DataDict.getChineseValueByCode(EStandTables.性别表, jhrxb);
            } catch (DictIsNotFoundException e) {
                return "__性别不符合标准表";
            }
        }
        return "";
    }

    /**
     * 校验家庭关系
     * @param jhrgx
     * @return
     */
    public String checkJhrgx(String jhrgx){
        //监护人家庭关系 【家庭关系】：1、必填。2、多选一：父亲,母亲,祖父母/外祖父母,兄弟姐妹,其他亲属,非亲属。
        if(BaseChecks.hasEmptyStr(jhrgx)) {
            return "__家庭关系不能为空";
        }
        if(!BaseChecks.hasEmptyStr(jhrgx)) {
            try {
                DataDict.getChineseValueByCode(EStandTables.家庭关系表, jhrgx);
            } catch (DictIsNotFoundException e) {
                return "__家庭关系不符合标准值";
            }
        }
        return "";
    }

    /**
     * 监护人证件号码
     * @param jhrzjhm
     * @param jhrzjlx
     * @param jhrxb
     * @return
     */
    public String checkJhrzjhm(String jhrzjhm,String jhrzjlx,String jhrxb) {
        /**
         【监护人身份证号码】
         1、不允许有中文字符
         2、家长【身份证件类型】为“居民身份证”时：只允许大写字母'X'和数字(0,1,2,3,4,5,6,7,8,9)，且X只能在最后一位。
         3、家长【身份证件类型】为“居民身份证”时：与学生的【性别】比较是否一致
         4、家长【身份证件类型】为“居民身份证”时：长度满足18位
         5、不允许重复
         6、必填，但家庭成员【身份证件类型】为“其他”时不填。
         7、存在英文字母时，需大写。
         */
        if(BaseChecks.hasEmptyStr(jhrzjhm) && !("F".equals(jhrzjlx) || "G".equals(jhrzjlx))) {
            return "__监护人证件号码请填写";
        }
        if(!BaseChecks.hasEmptyStr(jhrzjhm) && !BaseChecks.hasEmptyStr(jhrzjlx)) {
            if("1".equals(jhrzjlx)) {
                if(18!=jhrzjhm.length()) {
                    return "__监护人证件类型为居民身份证，需要填写18位";
                }
                if(!isCardId(jhrzjhm)) {
                    return "__监护人身份证填写错误";
                }
                if(BaseChecks.isChineseChar(jhrzjhm)) {
                    return "__监护人身份证不允许有中文字符";
                }
                if(jhrzjhm.contains("X")) {
                    //走正则
                    if(!jhrzjhm.matches("[0-9]{17}X")) {
                        return "__为“居民身份证”时：只允许大写字母'X'和数字(0,1,2,3,4,5,6,7,8,9)，且X只能在最后一位。";
                    }
                }
                String jhrzjhmxb = jhrzjhm.substring(jhrzjhm.length()-2,jhrzjhm.length()-1);
                Integer intXb = Integer.parseInt(jhrzjhmxb);
                //除不尽就是男   性别字段 xb：1是男，2是女
                if (0==(intXb%2)) {
                    if ("1".equals(jhrxb))
                        return "__监护人身份证和性别不匹配";
                } else {
                    if ("2".equals(jhrxb))
                        return "__监护人身份证和性别不匹配";
                }
            }
        }
        return "";
    }

    /**
     * 监护人联系电话
     * @param jhrdh
     * @return
     */
    public String checkJhrdh(String jhrdh){
        //【联系电话】：1、必填。2、只允许数字和英文中划线、英文空格。
        if(BaseChecks.hasEmptyStr(jhrdh))
            return "__请填写监护人联系电话";

        if(!BaseChecks.hasEmptyStr(jhrdh)) {
            //不为空
            if (!jhrdh.matches("[0-9]{3}[/-]{1}[0-9]{8}||[0-9]{11}"))
                return "__家庭联系人电话必须为11位数或者为：区号-开头的";
        }
        return "";
    }

    /**
     *居住证类型校验
     * @param jzzlx
     * @param sfzjlx
     * @param hksf
     * @return
     */
    public String checkJzzlx(String jzzlx,String sfzjlx,String hksf) {
        //1、字典
        // 2、【身份证件类型】为“1居民身份证”时，且【户口省份】不为‘310000上海市’时
        //3、【身份证件类型】为“香港特区身份证明、澳门特区身份证明、台湾居民来往大陆通行证、境外永久居住证、护照”时填写。
        if("1".equals(sfzjlx)&&!"310000".equals(hksf)) {
            if(BaseChecks.hasEmptyStr(jzzlx)) {
                return "__居住证类型请选择";
            }
        }
        //当证件类型为：为“D(香港特区身份证明、澳门特区身份证明)、8台湾居民来往大陆通行证、9境外永久居住证、A护照”时填写。
        if("D".equals(sfzjlx)
                ||"8".equals(sfzjlx)||"9".equals(sfzjlx)||"A".equals(sfzjlx)
                ||"Z".equals(sfzjlx)) {
            if(BaseChecks.hasEmptyStr(jzzlx)) {
                return "__居住证类型请选择";
            }
        }
        return "";
    }

    /**
     * 居住证号码校验
     * @param jzzhm
     * @param jzzlx
     * @return
     */
    public String checkJzzhm(String jzzhm,String jzzlx) {
        //当居住证类型不为空
        if(!BaseChecks.hasEmptyStr(jzzlx)) {
            //1、【居住证类型】不为空和“暂无”时             2、只允许填写英文大写字母和数字。
            if(!"0".equals(jzzlx)) {
                if(BaseChecks.hasEmptyStr(jzzhm)) {
                    return "__请填写监护人居住证号码";
                }
            }
            if(!BaseChecks.hasEmptyStr(jzzhm)){
                //正则校验
                if(!jzzhm.matches("^[A-Z0-9]+$")){
                    return "__居住证号码只允许填写英文大写字母和数字。";
                }
            }
        }
        return "";
    }

    /**
     * 居住证有效期
     * @param jzzyxq
     * @param jzzlx
     * @return
     */
    public String checkJzzyxq(String jzzyxq, String jzzlx) {
        if(!BaseChecks.hasEmptyStr(jzzlx)) {
            //1、【居住证类型】不为空和“暂无”时             2、只允许填写英文大写字母和数字。
            if(!"0".equals(jzzlx)) {
                if(BaseChecks.hasEmptyStr(jzzyxq)) {
                    return "__请选择居住证有效时间";
                }
            }
        }
        return  "";
    }

    /**
     * 户口性质
     * @param hkxz
     * @param sfzjlx
     * @return
     */
    public String checkHkxz(String hkxz,String sfzjlx) {
        //字典 【身份证件类型】为1居民身份证时填写
        if("1".equals(sfzjlx)) {
            if(BaseChecks.hasEmptyStr(hkxz)) {
                return "__请选择户口性质";
            }
            if(!BaseChecks.hasEmptyStr(hkxz)) {
                //非农业户口类型 必填
                try {
                    DataDict.getChineseValueByCode(EStandTables.户口性质表, hkxz);
                } catch (DictIsNotFoundException e) {
                    return "__非农业户口类型不符合标准表";
                }

            }
        }
        return "";
    }

    /**
     * 请填写非农业户口类型校验
     * @param fnhklx  非农户口类型
     * @param hkxz 户口新增
     * @return
     */
    public String checkFnhklx(String fnhklx,String hkxz) {
        //【户口性质】为“非农业家庭户口”和“非农业集体户口”时
        if("1".equals(hkxz) || "3".equals(hkxz)) {
            if(BaseChecks.hasEmptyStr(hkxz)) {
                return "__请填写非农业户口类型";
            }
            if(!BaseChecks.hasEmptyStr(fnhklx)) {
                //非农业户口类型 必填
                try {
                    DataDict.getChineseValueByCode(EStandTables.非农业户口类型表, fnhklx);
                } catch (DictIsNotFoundException e) {
                    return "__非农业户口类型不符合标准表";
                }
            }
        }
        return "";
    }

    /**
     * 户籍类别
     * @param hjlb
     * @param sfzjlx
     * @return
     */
    public String checkHjlb(String hjlb,String sfzjlx) {
        /**
         字典
         1、当【身份证件类型】为“居民身份证时”时，在“常驻、蓝印、外省市”三个中选一个填写。
         2、当【身份证件类型】为“其他”时，在“常驻、蓝印”两个中选一个填写。
         3、当【身份证件类型】为“香港特区身份证明、澳门特区身份证明、台湾居民来往大陆通行证”时，只能选择“港澳台侨”。
         4、当【身份证件类型】为“境外、护照”时，只能选择“外籍”。
         */
        //户籍类别
        if(BaseChecks.hasEmptyStr(hjlb)) {
            return "__户籍类别请选择";
        }
        if(!BaseChecks.hasEmptyStr(hjlb)) {
            //当户籍类别填写
            //1.【证件类型】为“居民身份证”时，“常驻，蓝印，外省市”中三选一。
            if("1".equals(sfzjlx)) {
                if("1".equals(hjlb)||"2".equals(hjlb)||"3".equals(hjlb)) {
                } else  {
                    return "__证件类型“居民身份证”时，户籍类别“常驻，蓝印，外省市”中三选一。";
                }
            }
            //2【证件类型】为“其他”时，“常驻、蓝印”二选一。
            if("Z".equals(sfzjlx)) {
                if("1".equals(hjlb)||"2".equals(hjlb)) {

                }else {
                    return "__证件类型为“其他”时，户籍类别“常驻、蓝印”二选一。";
                }
            }
            //3 D(“香港特区身份证明、澳门特区身份证明)、台湾居民来往大陆通行证”时，只能选“港澳台侨”
            if("D".equals(sfzjlx)||"8".equals(sfzjlx)) {
                if(!"4".equals(hjlb)) {
                    return "__证件类型为香港特区身份证明、澳门特区身份证明、台湾居民来往大陆通行证”时，只能选“港澳台侨”。";
                }
            }
            //4.【证件类型】为“境外、护照”时，只能选“外籍”。
            if("9".equals(sfzjlx)||"A".equals(sfzjlx)) {
                if(!"5".equals(hjlb)) {
                    return "__证件类型为“境外、护照”时，只能选“外籍”。";
                }
            }
        }
        return  "";
    }

    /**
     * 是否人户一致
     * @param sfrhyz
     * @return
     */
    public  String checkSfrhyz(String sfrhyz) {
        if(!BaseChecks.hasEmptyStr(sfrhyz)) {
            //是否人户一致
            try {
                DataDict.getChineseValueByCode(EStandTables.是否标志表, sfrhyz);
            } catch (DictIsNotFoundException e) {
                return "__是否人户一致不符合标准表";
            }
        }
       return "";
    }

    /**
     * 户籍登记日期
     * @param hjdjr
     * @param sfzjlx
     * @return
     */
    public String checkHjdjr(String hjdjr,String sfzjlx) {
        if("1".equals(sfzjlx)) {
            if(!BaseChecks.hasEmptyStr(hjdjr)) {
                if(hjdjr.contains("-")) {
                    hjdjr = hjdjr.replace("-","");
                }
                if(!isBirthday(hjdjr)) {
                    return "__户籍登记日期填写不准确";
                }
            }
        }
       return "";
    }

    /**
     * 户主关系
     * @param hzgx
     * @param sfzjlx
     * @return
     */
    public String checkHzgx(String hzgx,String sfzjlx) {
        //户主关系1、字典            2、【身份证件类型】为1居民身份证时
        if("1".equals(sfzjlx)) {
            if(BaseChecks.hasEmptyStr(hzgx)) {
                return "__请选择与户主关系";
            }
            if(!BaseChecks.hasEmptyStr(hzgx)) {
                try {
                    DataDict.getChineseValueByCode(EStandTables.户主关系表, hzgx);
                } catch (DictIsNotFoundException e) {
                    return "__与户主关系不符合标准表";
                }
            }
        }
        return "";
    }

    /**
     * 户口省份
     * @param sfzjlx
     * @param hksf
     * @return
     */
    public String checkHksf(String sfzjlx,String hksf){
        if("1".equals(sfzjlx)) {
            /**
             1、【身份证件类型】为1居民身份证时，必填
             2、【户籍类别】为“常驻”和“蓝印”时，默认为“上海市”
             3、字典
             */
            if(BaseChecks.hasEmptyStr(hksf)) {
                return "__请选择户口省份";
            }
            //户口省份
            if(!BaseChecks.hasEmptyStr(hksf)) {
                try {
                    DataDict.getChineseValueByCode(EStandTables.省份城市表, hksf);
                } catch (DictIsNotFoundException e) {
                    return "__户口省份不符合标准表";
                }
            }
        }
        return "";
    }

    /**
     * 上海市校验户口街道信息
     * @param registerStudent
     * @return
     */
    public String checkShHksf(Map<String,Object> registerStudent) {
        //当为居民身份证时候校验
        //当省份为：上海市的时候校验。户口街道，户口居委
        String hksf = (String) registerStudent.get("hksf");
        if(!BaseChecks.hasEmptyStr(hksf)) {
            if("310000".equals(hksf)) {
//                    1、【身份证件类型】为1居民身份证时，必填
//                    2、【户籍类别】为“常驻”和“蓝印”时，默认为“上海市”
//                    3、字典
                if(!"310100".equals(registerStudent.get("hkcity"))) {
                    return "__请选择户口市";
                }
                String hkjz = (String) registerStudent.get("hkjz");//户口街镇
                if(BaseChecks.hasEmptyStr(hkjz)) {
                    return "__户口街镇请选择";
                }
                if(!BaseChecks.hasEmptyStr(hkjz)) {
                    try {
                        DataDict.getChineseValueByCode(EStandTables.街道表, hkjz);
                    } catch (DictIsNotFoundException e) {
                        return "__户口街道不符合标准表";
                    }
                }
                String hkjwh = (String) registerStudent.get("hkjwh");//居委
                if(BaseChecks.hasEmptyStr(hkjwh)) {
                    return "__户口居委请选择";
                }
                if(!BaseChecks.hasEmptyStr(hkjwh)) {
                    try {
                        DataDict.getChineseValueByCode(EStandTables.居委表, hkjwh);
                    } catch (DictIsNotFoundException e) {
                        return "__户口居委不符合标准表";
                    }
                }
                String hkrod = (String) registerStudent.get("hkrod");//户口路
                if(BaseChecks.hasEmptyStr(hkrod)) {
                    return "__户口路请填写";
                }
                String hkz = (String) registerStudent.get("hkz");//户口组
                if(BaseChecks.hasEmptyStr(hkz)) {
                    return "__户口组请填写";
                }
                String hkldh = (String) registerStudent.get("hkldh");//户口所在的楼栋号
                if(BaseChecks.hasEmptyStr(hkldh)) {
                    return "__户口所在的楼栋号请填写";
                }
                String hks = (String) registerStudent.get("hks");//户口所在的室
                if(BaseChecks.hasEmptyStr(hks)) {
                    return "__户口所在的室请填写";
                }
            }
        }
        return "";
    }

    /**
     * 外省，只需要校验。户口详细地址
     * @param hksf
     * @param wsshkdz
     * @return
     */
    public String checkWsHksf(String hksf,String wsshkdz) {
        //                hkcity 户口市和 wsshkdz 外省市户口地址
        if(!"310000".equals(hksf)) {
            if(BaseChecks.hasEmptyStr(wsshkdz)) {
                return "__请填写户口详细地址";
            }
        }
        return "";
    }

    /**
     * 户口区县
     * @param hkqx
     * @param sfzjlx
     * @return
     */
    public String checkHkqx(String hkqx,String sfzjlx){
        //户口区县 1、字典           2、【身份证件类型】为1居民身份证时
//        String hkqx = (String) registerStudent.get("hkqx");
        if("1".equals(sfzjlx)) {
            if(BaseChecks.hasEmptyStr(hkqx)) {
                return "__请选择户口区县";
            }
            try {
                DataDict.getChineseValueByCode(EStandTables.省份城市表, hkqx);
            } catch (DictIsNotFoundException e) {
                return "__户口区县不符合标准表";
            }
        }
        return "";
    }

    /**
     * 现居住地省份
     * @param xzzsf
     * @return
     */
    public String checkXzzsf(String xzzsf) {
//        String xzzsf = (String) registerStudent.get("xzzsf");//现在居住地
        if(BaseChecks.hasEmptyStr(xzzsf)) {
            return "__请选择现居住地省份";
        }
        if(!BaseChecks.hasEmptyStr(xzzsf)) {
            if(!"310100".equals(xzzsf)) {
                return "__现居住地省份必须为上海市";
            }
        }
        return  "";
    }

    /**
     * 现居住地区县
     * @param xzzqx
     * @return
     */
    public String checkXzzqx(String xzzqx) {
        if(BaseChecks.hasEmptyStr(xzzqx)) {
            return "__请选择现居住地区县";
        }
        if(!BaseChecks.hasEmptyStr(xzzqx)) {
            try {
                DataDict.getChineseValueByCode(EStandTables.区县表, xzzqx);
            } catch (DictIsNotFoundException e) {
                return "__现居住地区县不符合标准表";
            }
        }
        return "";
    }

    /**
     * 现居住街道
     * @param xzzjd
     * @return
     */
    public String checkXzzjd(String xzzjd) {
//        String xzzjd = (String) registerStudent.get("xzzjd");
        if(BaseChecks.hasEmptyStr(xzzjd)) {
            return "__请选择现居住地街道";
        }
        if(!BaseChecks.hasEmptyStr(xzzjd)) {
            try {
                DataDict.getChineseValueByCode(EStandTables.街道表, xzzjd);
            } catch (DictIsNotFoundException e) {
                return "__现居住地街道不符合标准表";
            }
        }
        return  "";
    }

    /**
     * 现居住居委
     * @param xzzjw
     * @return
     */
    public String checkXzzjw(String xzzjw) {
//        String xzzjw = (String) registerStudent.get("xzzjw");
        if(BaseChecks.hasEmptyStr(xzzjw)) {
            return "__请选择现居住地居委";
        }
        if(!BaseChecks.hasEmptyStr(xzzjw)) {
            try {
                DataDict.getChineseValueByCode(EStandTables.居委表, xzzjw);
            } catch (DictIsNotFoundException e) {
                return "__现居住地居委不符合标准表";
            }
        }
        return  "";
    }

    /**
     * 现居住地址路
     * @param xzzrod
     * @return
     */
    public String checkXzzrod(String xzzrod) {
//        String xzzrod = (String) registerStudent.get("xzzrod");
        if(BaseChecks.hasEmptyStr(xzzrod)) {
            return "__请填写现居住地址路";
        }
        return "";
    }

    /**
     * 居住组
     * @param xzzz
     * @return
     */
    public String checkXzzz(String xzzz) {
//        String xzzz = (String) registerStudent.get("xzzz");
        if(BaseChecks.hasEmptyStr(xzzz)) {
            return "__请填写现住址所在的弄（组）";
        }
        return "";
    }

    /**
     * 现住址楼栋号
     * @return
     */
    public String checkXzzldh(String xzzldh) {
//        String xzzldh = (String) registerStudent.get("xzzldh");
        if(BaseChecks.hasEmptyStr(xzzldh)) {
            return "__请填写现住址楼栋号";
        }
        return "";
    }

    /**
     * 现住址室
     * @return
     */
    public String checkXzzs(String xzzs) {
//        String xzzs = (String) registerStudent.get("xzzs");
        if(BaseChecks.hasEmptyStr(xzzs)) {
            return "__请填写现住址室";
        }
        return "";
    }

    /**
     * 现居住邮编
     * @param xzzyzbm
     * @return
     */
    public String checkXzzyzbm(String xzzyzbm) {
        //现居住地邮编 必填 2开头的六位数字.
//        String xzzyzbm = (String) registerStudent.get("xzzyzbm");
        if(!"2".equals(xzzyzbm.substring(0,1))){
            return "__邮编首位必须为2开头";
        }
        if (!xzzyzbm.matches("[0-9]{6}")) {
            return "__邮编不符合6位数要求、";
        }
        return "";
    }

    /**
     * 联系电话
     * @param lxdh
     * @return
     */
    public String checkLxdh(String lxdh) {
        //联系电话 只允许最多11个字符（0 1 2 3 4 5 6 7 8 9 - 的组合），首位只允许数字。
//        String lxdh = (String) registerStudent.get("lxdh");
        if(BaseChecks.hasEmptyStr(lxdh)) {
            return "__联系电话不能为空、";
        }
        if(!BaseChecks.hasEmptyStr(lxdh)) {
            if (!lxdh.matches("[0-9]{3}[/-]{1}[0-9]{8}||[0-9]{11}")) return "学生联系电话必须为11位数或者为：区号-开头的";
        }
        return "";
    }

    /**
     * 住房性质
     * @param registerStudent
     * @return
     */
    public String checkZfxz(Map<String,Object> registerStudent) {
        //住房性质
        String zfxz = (String) registerStudent.get("zfxz");
        if(BaseChecks.hasEmptyStr(zfxz)) {
            return "__住房性质必填、";
        }
        //产权房
        if(!BaseChecks.hasEmptyStr(zfxz)) {
            try {
                DataDict.getChineseValueByCode(EStandTables.住房性质表, zfxz);
            } catch (DictIsNotFoundException e) {
                return "__住房性质不符合标准表";
            }
            //【住房性质】为“产权房”时必填 ,【住房性质】为“产权房”时必填
            if ("4".equals(zfxz)) {
                if(BaseChecks.hasEmptyStr((String) registerStudent.get("czbh"))) {
                    return "__住房性质为产权房，产权房产证编号必填、";
                }
                String djrq =  (String) registerStudent.get("djrq");
                if(BaseChecks.hasEmptyStr(djrq)) {
                    return "__住房性质为产权房，产权房登记日期必填、";
                }else {
                    if(isBirthday(djrq)){
                        return "__产权房登记日期格式不准确,如:20120302、";
                    }
                }
                if(BaseChecks.hasEmptyStr((String) registerStudent.get("cqfdz"))) {
                    return "__住房性质为产权房，产权房地址必填、";
                }
            }

            //【住房性质】为“租赁”时必填 【住房性质】为“租赁”时必填
            if("1".equals(zfxz)||"3".equals(zfxz)) {
                if(BaseChecks.hasEmptyStr((String) registerStudent.get("htbh"))) {
                    return "__【住房性质】为“公/廉租房”和“租赁”时，合同编号必填。、";
                }
                if(BaseChecks.hasEmptyStr((String) registerStudent.get("qzrq"))) {
                    return "__【住房性质】为“公/廉租房”和“租赁”时,起租日期必填。、";
                }
            }
            if("5".equals(zfxz)) {
                if(BaseChecks.hasEmptyStr((String) registerStudent.get("zfqt"))) {
                    return "__【住房性质】为其他，请填写住房其他原因";
                }
            }
        }
        return "";
    }

    /**
     * 购房人关系
     * @param gfrgx
     * @return
     */
    public String checkGfrgx(String gfrgx){
        //购房人关系
//        String gfrgx = (String) registerStudent.get("gfrgx");
        if(BaseChecks.hasEmptyStr(gfrgx)){
            return "__请选择购房人关系";
        }
        if(!BaseChecks.hasEmptyStr(gfrgx)){
            try {
                DataDict.getChineseValueByCode(EStandTables.户主关系表, gfrgx);
            } catch (DictIsNotFoundException e) {
                return "__购房人关系不符合标准表";
            }
        }
        return "";
    }

    /**
     * 是否农民工同住子女
     * @param sfzjlx
     * @param sfnmgtzzn
     * @return
     */
    public String checkSfnmgtzzn(String sfzjlx,String sfnmgtzzn,String hjlb){
//        String sfnmgtzzn = (String) registerStudent.get("sfnmgtzzn");
        //是否农民工同住子女	C 		是否项。【身份证件类型】为1居民身份证时
        if("1".equals(sfzjlx)) {
            if(!("1".equals(hjlb) || "2".equals(hjlb))) {
//            String sfnmgtzzn = (String) registerStudent.get("sfnmgtzzn");
                if(BaseChecks.hasEmptyStr(sfnmgtzzn)){
                    return "__请选择是否农民工同住子女";
                }
                if(!BaseChecks.hasEmptyStr(sfnmgtzzn)){
                    try {
                        DataDict.getChineseValueByCode(EStandTables.是否标志表, sfnmgtzzn);
                    } catch (DictIsNotFoundException e) {
                        return "__是否农民工同住子女不符合标准表";
                    }
                }
            }
        }
        return "";
    }

    /**
     * 是否领取残疾证
     * @param registerStudent
     * @return
     */
    public String checkSflqcjz(Map<String,Object> registerStudent) {
        String sflqcjz = (String) registerStudent.get("sflqcjz");
        if(BaseChecks.hasEmptyStr(sflqcjz)){
            return "__请选择是否领取残疾证";
        }
        if(!BaseChecks.hasEmptyStr(sflqcjz)){
            try {
                DataDict.getChineseValueByCode(EStandTables.是否标志表, sflqcjz);
            } catch (DictIsNotFoundException e) {
                return "__是否领取残疾证不符合标准表";
            }
            //当为为残疾幼儿的时候
            if("1".equals(sflqcjz)) {
                String cjlb = (String) registerStudent.get("cjlb");
                if(BaseChecks.hasEmptyStr(cjlb)){
                    return "__请选择残疾类别";
                }
                if(!BaseChecks.hasEmptyStr(cjlb)){
                    try {
                        DataDict.getChineseValueByCode(EStandTables.残疾类别表, cjlb);
                    } catch (DictIsNotFoundException e) {
                        return "__残疾类别不符合标准表";
                    }
                }
                String cjzbh = (String) registerStudent.get("cjzbh");
                String cjzfzrq = (String) registerStudent.get("cjzfzrq");
                String cjzfzjg = (String) registerStudent.get("cjzfzjg");
                if(BaseChecks.hasEmptyStr(cjzbh)){
                    return "__请填写残疾证编号";
                }
                if(BaseChecks.hasEmptyStr(cjzfzrq)){
                    return "__请填写残疾证发证日期";
                }
                if(BaseChecks.hasEmptyStr(cjzfzjg)){
                    return "__请填写残疾证发证机关";
                }
            }
        }
        return "";
    }

    /**
     * 入园依据
     * @param ryyj
     * @return
     */
    public String checkRyyj(String ryyj) {
//        String ryyj = (String) registerStudent.get("ryyj");
        if(BaseChecks.hasEmptyStr(ryyj)){
            return "__请选择入园依据";
        }
        if(!BaseChecks.hasEmptyStr(ryyj)){
            try {
                DataDict.getChineseValueByCode(EStandTables.入园依据表, ryyj);
            } catch (DictIsNotFoundException e) {
                return "__入园依据不符合标准表";
            }
        }
        return "";
    }

    /**
     * 入园依据类别
     * @param ryyjlb
     * @return
     */
    public String checkRyyjlb(String ryyjlb) {
//        String ryyjlb = (String) registerStudent.get("ryyjlb");
        if(BaseChecks.hasEmptyStr(ryyjlb)){
            return "__请选择入园依据类别";
        }
        if(!BaseChecks.hasEmptyStr(ryyjlb)){
            try {
                DataDict.getChineseValueByCode(EStandTables.入园依据类别表, ryyjlb);
            } catch (DictIsNotFoundException e) {
                return "__入园依据类别不符合标准表";
            }
        }
        return "";
    }

    /**
     * 金山特有的入园依据类别校验，没有查询数据库
     * @return
     */
    public String checkJsRyyjlb(Map<String,Object> registerStudent) {
        String sfzjlx = (String) registerStudent.get("sfzlx");
        String ryyj = (String) registerStudent.get("ryyj");
        String hjlb = (String) registerStudent.get("hjlb");
        String ryyjlb = (String) registerStudent.get("ryyjlb");
        //入园依据类别
        //1.学生【证件类型】为“居民身份证”或“其他”
        if("1".equals(sfzjlx)||"Z".equals(sfzjlx)) {
            if(!BaseChecks.hasEmptyStr(ryyj) && !BaseChecks.hasEmptyStr(ryyjlb)){
                //+【户籍类别】为“常驻”或“蓝印”的， 上海市
                if("1".equals(hjlb) || "2".equals(hjlb)) {
                    if("10".equals(ryyj)) {
                        if("10".equals(ryyjlb) || "11".equals(ryyjlb) || "12".equals(ryyjlb)) {
                        } else {
                            return "__入园依据类别请选择，本地段户籍，本区户籍，本市外区县户籍";
                        }
                    }
                    if("50".equals(ryyj)) {
                        if("50".equals(ryyjlb) || "51".equals(ryyjlb) || "52".equals(ryyjlb)) {
                        } else {
                            return "__入园依据类别请选择，本地段户籍，本区户籍，本市外区县户籍";
                        }
                    }
                }
            }
        }
        //外省市
        if("1".equals(sfzjlx)&&"3".equals(hjlb)) {
            if("10".equals(ryyj)) {
                if("13".equals(ryyjlb) || "14".equals(ryyjlb) || "15".equals(ryyjlb)) {
                } else {
                    return "__入园依据类别请选择:居住证标准积分,居住证,双证";
                }
            }
            if("50".equals(ryyj)) {
                if("53".equals(ryyjlb) || "54".equals(ryyjlb) || "55".equals(ryyjlb)) {
                } else {
                    return "__入园依据类别请选择:居住证标准积分,居住证,双证";
                }
            }
            if("20".equals(ryyj) || "30".equals(ryyj) || "40".equals(ryyj)) {
                return "__入园依据请选择,普通房产，合法居住证明，入园依据类别:居住证标准积分,居住证,双证";
            }
        }
        //3“香港特区身份证明、澳门特区身份证明、台湾居民来往大陆通行证” “境外、护照
        //
        if("D".equals(sfzjlx)||"8".equals(sfzjlx)||"9".equals(sfzjlx)||"A".equals(sfzjlx)) {

            if("10".equals(ryyj)) {
                if("16".equals(ryyjlb) || "17".equals(ryyjlb) ) {
                } else {
                    return "__入园依据类别请选择：港澳台,外籍";
                }
            }
            if("50".equals(ryyjlb)) {
                if("56".equals(ryyjlb) || "57".equals(ryyjlb)) {
                } else {
                    return "__入园依据类别请选择：港澳台,外籍";
                }
            }
            if("20".equals(ryyj) || "30".equals(ryyj) || "40".equals(ryyj)) {
                return "__入园依据请选择,普通房产，合法居住证明，入园依据类别:港澳台,外籍";
            }
        }
        return "";
    }

    /**
     * 生源情况
     * @param syqk
     * @return
     */
    public String checkSyqk(String syqk) {
        //生源情况
//        String syqk = (String) registerStudent.get("syqk");
        if(BaseChecks.hasEmptyStr(syqk)){
            return "__请填写生源情况";
        }
        if(!BaseChecks.hasEmptyStr(syqk)){
            try {
                DataDict.getChineseValueByCode(EStandTables.生源情况表, syqk);
            } catch (DictIsNotFoundException e) {
                return "__生源情况不符合标准表";
            }
        }
        return "";
    }

    /**
     * 监护人学历
     * @param jhrxl
     * @return
     */
    public String checkJhrxl(String jhrxl) {
        //监护人信息校验：1.监护人学历
//        String jhrxl = (String) registerStudent.get("jhrxl");
        if(BaseChecks.hasEmptyStr(jhrxl)) {
            return "__请选择监护人学历";
        }
        if(!BaseChecks.hasEmptyStr(jhrxl)) {
            try {
                DataDict.getChineseValueByCode(EStandTables.学历表, jhrxl);
            } catch (DictIsNotFoundException e) {
                return "__监护人学历不符合标准表";
            }
        }
        return "";
    }

    /**
     * 监护人工作单位
     * @param jhrgzdw
     * @return
     */
    public String checkJhrgzdw(String jhrgzdw) {
//        String jhrgzdw = (String) registerStudent.get("jhrgzdw");
        if(BaseChecks.hasEmptyStr(jhrgzdw)) {
            return "__请填写监护人工作单位";
        }
        return "";
    }

    /**
     * 监护人 户口省份，区县
     * @return
     */
    public String checkJhrhksf(Map<String,Object> registerStudent ) {
        String jhrjzzlx = (String) registerStudent.get("jhrjzzlx");
        String jhrzjlx = (String) registerStudent.get("jhrzjlx");
        if("1".equals(jhrzjlx)) {
            //当证件类型为居民身份证，校验，户口区县？
            String jhrhksf = (String) registerStudent.get("jhrhksf");
            String jhrqx = (String) registerStudent.get("jhrqx");
            if(BaseChecks.hasEmptyStr(jhrhksf)) {
                return "__请选择监护人户口省/市";
            }
            if(BaseChecks.hasEmptyStr(jhrqx)) {
                return "__请选择监护人户口市/区县";
            }
            //当证件类型为身份证件类型，户口省份不为上海市
            if(!BaseChecks.hasEmptyStr(jhrhksf)) {
                if(!"310000".equals(jhrhksf)) {
                    if(BaseChecks.hasEmptyStr(jhrjzzlx)) {
                        return "__监护人居住证类型请选择";
                    }
                }
            }
        }
        return "";
    }

    /**
     * 监护人证件类型，居住证类型
     * @param registerStudent
     * @return
     */
    public String checkJhrjzzlx(Map<String,Object> registerStudent) {
        String jhrzjlx = (String) registerStudent.get("jhrzjlx");
        String jhrjzzlx = (String) registerStudent.get("jhrjzzlx");
        //当证件类型为：为“D(香港特区身份证明、澳门特区身份证明)、8台湾居民来往大陆通行证、9境外永久居住证、A护照”时填写。
        if("D".equals(jhrzjlx)
                ||"8".equals(jhrzjlx)||"9".equals(jhrzjlx)||"A".equals(jhrzjlx)
                ||"Z".equals(jhrzjlx)) {
            if(BaseChecks.hasEmptyStr(jhrjzzlx)) {
                return "__监护人居住证类型请选择";
            }
        }
        if(!BaseChecks.hasEmptyStr(jhrjzzlx)) {
            if(!"0".equals(jhrjzzlx)) {
                String jhrjzzhm = (String) registerStudent.get("jhrjzzhm");
                if(BaseChecks.hasEmptyStr(jhrjzzhm)) {
                    return "__请填写监护人居住证号码";
                }
                String jhrjzzyxq = (String) registerStudent.get("jhrjzzyxq");
                if(BaseChecks.hasEmptyStr(jhrjzzyxq)) {
                    return "__请选择监护人居住证有效时间";
                }
            }
            //监护人居住证类型为上海居住证。
            if("1".equals(jhrjzzlx)) {
                String jhrsfbzf = (String) registerStudent.get("jhrsfbzf");
                //监护人积分是否达标选择
                if(BaseChecks.hasEmptyStr(jhrsfbzf)) {
                    return "__请选择监护人居住证是否积分达标";
                }
            }
            //临时居住证
            if("L".equals(jhrjzzlx)) {
                String jhrlssj = (String) registerStudent.get("jhrlssj");
                if(BaseChecks.hasEmptyStr(jhrlssj)) {
                    return "__请选择监护人临时居住证办证时间";
                }
                String jhrsflhjy = (String) registerStudent.get("jhrsflhjy");
                if(BaseChecks.hasEmptyStr(jhrsflhjy)) {
                    return "__请选择监护人是否灵活就业";
                }
                if(!BaseChecks.hasEmptyStr(jhrsflhjy)) {
                    if("1".equals(jhrsflhjy)) {
                        String jhrlhjybh = (String) registerStudent.get("jhrlhjybh");
                        if(BaseChecks.hasEmptyStr(jhrlhjybh)) {
                            return "__请填写监护人是否灵活就业";
                        }
                        String jhrsyhylb = (String) registerStudent.get("jhrsyhylb");
                        if(BaseChecks.hasEmptyStr(jhrsyhylb)) {
                            return "__请选择监护人就业行业类别";
                        }
                        String jydjcs = (String) registerStudent.get("jydjcs");
                        if(BaseChecks.hasEmptyStr(jydjcs)) {
                            return "__请填写监护人就业登记次数";
                        }
                    }
                }
            }
        }
        return "";
    }

    /**
     * 是否符合生日格式
     *
     * @param arg
     * @return
     */
    public static boolean isBirthday(String arg) {
        return arg == null ? false : arg.matches(REG_BIRTHDAY);
    }

    private static final String REG_BIRTHDAY = "(([0-9]{3}[1-9]|[0-9]{2}[1-9][0-9]{1}|[0-9]{1}[1-9][0-9]{2}|[1-9][0-9]{3})(((0[13578]|1[02])(0[1-9]|[12][0-9]|3[01]))" +"|((0[469]|11)(0[1-9]|[12][0-9]|30))|(02(0[1-9]|[1][0-9]|2[0-8]))))" +"|((([0-9]{2})(0[48]|[2468][048]|[13579][26])|((0[48]|[2468][048]|[3579][26])00))0229)";// 生日

    /**
     * 是否符合身份证格式
     * @param arg
     * @return
     */
    public static boolean isCardId(String arg) {
        return arg == null ? false : arg.matches(REG_CARDID);
    }
    private static final String REG_CARDID = "^[1-9][0-9]{5}(19[0-9]{2}|20[0-9]{2})(0[1-9]|1[0-2])(0[1-9]|[12][0-9]|3[01])[0-9]{3}[0-9X]$";// 身份证号

    /**
     * 校验学校代码是否存在
     * @param schoolCode
     * @param loginInfo
     * @return 默认返回查询不到数据 false ，查询到数据返回true，
     * @throws SQLException
     */
    private Boolean checkSchool(String schoolCode ,LoginInfo loginInfo) throws SQLException {
        QueryParams querySchool  = QueryParams.createQueryParams("vb_querySchool_lrs");
        querySchool.addQueryParams(Parameter.createParameter("schoolcode",schoolCode));
        try {
            querySchool.setDbLog(loginInfo);
        } catch (Exception e) {
            e.printStackTrace();
        }
        List<Map<String, Object>> schoolList = baseDaoComponent.selectDataByParams(querySchool);
        if(0<schoolList.size()) {
            return  true;
        }
        return false;
    }


}
